Match the commands ls, cd, pwd to their descriptions
ls lists contents of current directory
cd changes current directory
cd .. takes you up one level
cd alone takes you back home
pwd returns current directory
Given a folder structure diagram, a list of 'cd (path)' commands and target files, match the paths to the target files.
Use VSCode to create a folder. Within the folder create a .js file containing console.log('hello new world'); and save it.
Use node to execute a JavaScript file in the terminal

Label variables as either Primitive vs. Reference
primitives: strings, booleans, numbers, null and undefined
primitives are immutable
refereces: objects (including arrays)
references are mutable
Identify when to use . vs [] when accessing values of an object
dot syntax object.key
easier to read
easier to write
cannot use variables as keys
keys cannot begin with a number
bracket notation object["key]
allows variables as keys
strings that start with numbers can be use as keys
Write an object literal with a variable key using interpolation
put it in brackets to access the value of the variable, rather than just make the value that string
1
let a = "b";
2
let obj = {a: "letter_a", [a]: "letter b"}
Copied!
Use the obj[key] !== undefined pattern to check if a given variable that contains a key exists in an object
can also use (key in object) syntax interchangeably (returns a boolean)
Utilize Object.keys and Object.values in a function
Object.keys(obj) returns an array of all the keys in obj
Object.values(obj) returns an array of the values in obj
Iterate through an object using a for in loop
1
let printValues = function(obj) {
2
for (let key in obj) {
3
let value = obj[key];
4
console.log(value);
5
}
6
}
Copied!
Define a function that utilizes ...rest syntax to accept an arbitrary number of arguments
...rest syntax will store all additional arguments in an array
array will be empty if there are no additional arguments
1
let myFunction = function(str, ...strs) {
2
console.log("The first string is " + str);
3
console.log("The rest of the strings are:");
4
strs.forEach(function(str) {
5
console.log(str);
6
})
7
}
Copied!
Use ...spread syntax for Object literals and Array literals
1
let arr1 = ["a","b","c"];
2
let longer = [...arr1, "d", "e"]; // ["a", "b", "c", "d", "e"]
3
// without spread syntax, this would give you a nested array
4
let withoutRest = [arr1, "d", "e"] // [["a", "b", "c"], "d", "e"]
Copied!
Destructure an array to reference specific elements
```javascript
let array = [35,9];
let [firstEl, secondEl] = array;
console.log(firstEl); // => 35
console.log(secondEl); // => 9

Write a function that accepts a array as an argument and returns an object representing the count of each character in the array
1
//
2
let elementCounts = function(array) {
3
let obj = {};
4
array.forEach( function(el) {
5
if (el in obj) obj[el] += 1;
6
else obj[el] = 1;
7
})
8
return obj;
9
}
10
console.log(elementCounts(["e", "f", "g", "f"])); // => Object {e: 1, f: 2, g: 1}
Copied!

Given multiple plausible reasons, identify why functions are called "First Class Objects" in JavaScript.
they can be stored in variables, passed as arguments to other functions, and serve as return value for a function
supports same basic operations as other types (strings, bools, numbers)
higher-order functions take functions as arguments or return functions as values
Given a code snippet containing an anonymous callback, a named callback, and multiple console.logs, predict what will be printed
what is this referring to?
Write a function that takes in a value and two callbacks. The function should return the result of the callback that is greater.

Write a function, myFilter, that takes in an array and a callback as arguments. The function should mimic the behavior of Array#filter.
1
let myFilter = function(array, callback) {
2
let filtered = [];
3
for (let i = 0; i < array.length; i ++) {
4
if (callback(array[i])) {
5
filtered.push(array[i], i, array);
6
}
7
}
8
}
Copied!
Write a function, myEvery, that takes in an array and a callback as arguments. The function should mimic the behavior of Array#every.
1
let myEvery = function(array, callback) {
2
for (let i = 0; i < array.length; i ++) {
3
if (!callback(array[i], i, array)) {
4
return false
5
}
6
}
7
return true;
8
}
9
// with arrow function syntax
10
let myEvery = (array, callback) => {
11
for (let i =0; i < array.length; i ++) {
12
if (!callback(array[i])) {
13
return false
14
}
15
}
16
return true;
17
}
Copied!

Identify the difference between const, let, and var declarations
const - cannot reassign variable, scoped to block
let - can reassign variable, scoped to block
var - outdated, may or may not be reassigned, scoped to function. can be not just reassigned, but also redeclared!
a variable will always evaluate to the value it contains regardless of how it was declared
Explain the difference between const, let, and var declarations
var is function scoped—so if you declare it anywhere in a function, the declaration (but not assignment) is "hoisted"
so it will exist in memory as "undefined" which is bad and unpredictable
var will also allow you to redeclare a variable, while let or const will raise a syntax error. you shouldn't be able to do that!
const won't let you reassign a variable, but if it points to a mutable object, you will still be able to change the value by mutating the object
block-scoped variables allow new variables with the same name in new scopes
block-scoped still performs hoisting of all variables within the block, but it doesn't initialize to the value of undefined like var does, so it throws a specific reference error if you try to access the value before it has been declared
if you do not use var or let or const when initializing, it will be declared as global—THIS IS BAD
if you assign a value without a declaration, it exists in the global scope (so then it would be accessible by all outer scopes, so bad). however, there's no hoisting, so it doesn't exist in the scope until after the line is run
Predict the evaluation of code that utilizes function scope, block scope, lexical scope, and scope chaining
scope of a program means the set of variables that are available for use within the program
global scope is represented by the window object in the browser and the global object in Node.js
global variables are available everywhere, and so increase the risk of name collisions
local scope is the set of variables available for use within the function
when we enter a function, we enter a new scope
includes functions arguments, local variables declared inside function, and any variables that were already declared when the function is defined (hmm about that last one)
for blocks (denoted by curly braces {}, as in conditionals or for loops), variables can be block scoped
inner scope does not have access to variables in the outer scope
scope chaining—if a given variable is not found in immediate scope, javascript will search all accessible outer scopes until variable is found
so an inner scope can access outer scope variables
but an outer scope can never access inner scope variables
Define an arrow function
```javascript
let arrowFunction = (param1, param2) => {
let sum = param1 + param2;
return sum;
}

Given an arrow function, deduce the value of this without executing the code
arrow functions are automatically bound to the context they were declared in
unlike regular function which use the context they are invoked in (unless they have been bound using Function#bind)
if you implement an arrow function as a method in an object the context it will be bound to is NOT the object itself, but the global context
so you can't use an arrow function to define a method directly
```javascript
let obj = {
name: "my object",
unboundFunc: function () {
return this.name;
// this function will be able to be called on different objects
},

Define a method that references this on an object literal
when we use this in a method it refers to the object that the method is invoked on
it will let you access other pieces of information from within that object, or even other methods
method style invocation - object.method(args) (e.g. built in examples like Array#push, or String#toUpperCase)
context is set every time we invoke a function
function style invocation sets the context to the global object no matter what
being inside an object does not make the context that object! you still have to use method-style invocation
Utilize the built in Function#bind on a callback to maintain the context of this
when we call bind on a function, we get an exotic function back—so the context will always be the same for that new function

CALLING SOMETHING IN THE WRONG CONTEXT CAN MESS YOU UP!
could throw an error if it expects this to have some other method or whatever that doesn't exist
you could also overwrite values or assign values to exist in a space where they should not exist
if you call a function as a callback, it will set this to be the outer function itself, even if the function you were calling is a method that was called on a particular object
1
let cat = {
2
purr: function () {
3
console.log("meow");
4
},
5
purrMore: function () {
6
this.purr();
7
},
8
};
9
global.setTimeout(cat.purrMore, 5000); // 5 seconds later: TypeError: this.purr is not a function
Copied!

CALLING SOMETHING IN THE WRONG CONTEXT CAN MESS YOU UP!
could throw an error if it expects this to have some other method or whatever that doesn't exist
you could also overwrite values or assign values to exist in a space where they should not exist
if you call a function as a callback, it will set this to be the outer function itself, even if the function you were calling is a method that was called on a particular object
```javascript
let cat = {
purr: function () {
console.log("meow");
},
purrMore: function () {
this.purr();
},
};

we can use strict mode with "use strict"; this will prevent you from accessing the global object with this in functions, so if you try to call this in the global context and change a value, you will get a type error, and the things you try to access will be undefined

Boolean - Primitive
Null - Primitive
Undefined - Primitive
Number - Primitive
String - Primitive
Array - Reference
Object - Reference
Function - Reference

var is the historical keyword used for variable declaration.
var declares variables in function scope, or global scope if not inside a function.
We consider var to be deprecated and it is never used in this course.

let is the keyword we use most often for variable declaration.
let declares variables in block scope.
variables declared with let are re-assignable.

const is a specialized form of let that can only be used to initialize a variable.
Except when it is declared, you cannot assign to a const variable.
const scopes variables the same way that let does.